C++ 类成员函数

类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。

让我们看看之前定义的类 Box，现在我们要使用成员函数来访问类的成员，而不是直接访问这些类的成员：

    class Box
    {
       public:
          double length;         // 长度
          double breadth;        // 宽度
          double height;         // 高度
          double getVolume(void);// 返回体积
    };

成员函数可以定义在类定义内部，或者单独使用作用域区分符 :: 来定义。在类定义中定义的成员函数把函数声明为内联的，即便没有使用 inline 标识符。所以您可以按照如下方式定义 Volume() 函数：

    class Box
    {
       public:
          double length;      // 长度
          double breadth;     // 宽度
          double height;      // 高度

          double getVolume(void)
          {
             return length * breadth * height;
          }
    };

您也可以在类的外部使用作用域区分符 :: 定义该函数，如下所示：

    double Box::getVolume(void)
    {
        return length * breadth * height;
    }

:: 叫作用域区分符，指明一个函数属于哪个类或一个数据属于哪个类。 :: 可以不跟类名，表示全局数据或全局函数（即非成员函数）。

    int month;//全局变量
    int day;
    int year;
    void Set(int m,int d,int y)
    {
        ::year=y; //给全局变量赋值，此处可省略
        ::day=d;
        ::month=m;
    }

   Class Tdate
    {
        public:
            void Set(int m,int d,int y) //成员函数
            {
                ::Set(m,d,y); //非成员函数
            }
        private:
            int month;
            int day;
            int year;
    }

在这里，需要强调一点，在 :: 运算符之前必须使用类名。调用成员函数是在对象上使用点运算符（.），这样它就能操作与该对象相关的数据，如下所示：

    Box myBox;          // 创建一个对象

    myBox.getVolume();  // 调用该对象的成员函数

让我们使用上面提到的概念来设置和获取类中不同的成员的值：

    #include <iostream>

    using namespace std;

    class Box
    {
       public:
          double length;         // 长度
          double breadth;        // 宽度
          double height;         // 高度

          // 成员函数声明
          double getVolume(void);
          void setLength( double len );
          void setBreadth( double bre );
          void setHeight( double hei );
    };

    // 成员函数定义
    double Box::getVolume(void)
    {
        return length * breadth * height;
    }

    void Box::setLength( double len )
    {
        length = len;
    }

    void Box::setBreadth( double bre )
    {
        breadth = bre;
    }

    void Box::setHeight( double hei )
    {
        height = hei;
    }

    // 程序的主函数
    int main( )
    {
       Box Box1;                // 声明 Box1，类型为 Box
       Box Box2;                // 声明 Box2，类型为 Box
       double volume = 0.0;     // 用于存储体积

       // box 1 详述
       Box1.setLength(6.0); 
       Box1.setBreadth(7.0); 
       Box1.setHeight(5.0);

       // box 2 详述
       Box2.setLength(12.0); 
       Box2.setBreadth(13.0); 
       Box2.setHeight(10.0);

       // box 1 的体积
       volume = Box1.getVolume();
       cout << "Box1 的体积：" << volume <<endl;

       // box 2 的体积
       volume = Box2.getVolume();
       cout << "Box2 的体积：" << volume <<endl;
       return 0;
    }

当上面的代码被编译和执行时，它会产生下列结果：

    Box1 的体积： 210
    Box2 的体积： 1560

类中的成员函数与 inline

定义在类中的成员函数缺省都是内联的，如果在类定义时就在类内给出函数定义，那当然最好。如果在类中未给出成员函数定义，而又想内联该函数的话，那在类外要加上 inline，否则就认为不是内联的。例如：

    class A
    {
        public:void Foo(int x, int y) {  } // 自动地成为内联函数
    }

将成员函数的定义体放在类声明之中虽然能带来书写上的方便，但不是一种良好的编程风格，上例应该改成：

    // 头文件
    class A
    {
        public:
        void Foo(int x, int y);
    }
    // 定义文件
    inline void A::Foo(int x, int y){}

inline 是一种用于实现的关键字

关键字 inline 必须与函数定义体放在一起才能使函数成为内联，仅将inline 放在函数声明前面不起任何作用。

如下风格的函数 Foo 不能成为内联函数：

    inline void Foo(int x, int y); // inline 仅与函数声明放在一起
    void Foo(int x, int y){}

而如下风格的函数Foo 则成为内联函数：

    void Foo(int x, int y);
    inline void Foo(int x, int y) {}  // inline 与函数定义体放在一起

🔚